/* Predict.c, motion compensation routines                                    */



/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */



/*

 * Disclaimer of Warranty

 *

 * These software programs are available to the user without any license fee or

 * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims

 * any and all warranties, whether express, implied, or statuary, including any

 * implied warranties or merchantability or of fitness for a particular

 * purpose.  In no event shall the copyright-holder be liable for any

 * incidental, punitive, or consequential damages of any kind whatsoever

 * arising from the use of these programs.

 *

 * This disclaimer of warranty extends to the user of these programs and user's

 * customers, employees, agents, transferees, successors, and assigns.

 *

 * The MPEG Software Simulation Group does not represent or warrant that the

 * programs furnished hereunder are free of infringement of any third-party

 * patents.

 *

 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,

 * are subject to royalty fees to patent holders.  Many of these patents are

 * general enough such that they are unavoidable regardless of implementation

 * design.

 *

 */



#include <stdio.h>



#include "config.h"

#include "global.h"



/* private prototypes */

static void form_prediction _ANSI_ARGS_((unsigned char *src[], int sfield,

  unsigned char *dst[], int dfield,

  int lx, int lx2, int w, int h, int x, int y, int dx, int dy,

  int average_flag));



static void form_component_prediction _ANSI_ARGS_((unsigned char *src, unsigned char *dst,

  int lx, int lx2, int w, int h, int x, int y, int dx, int dy, int average_flag));



void form_predictions(bx,by,macroblock_type,motion_type,PMV,motion_vertical_field_select,dmvector,stwtype)

int bx, by;

int macroblock_type;

int motion_type;

int PMV[2][2][2], motion_vertical_field_select[2][2], dmvector[2];

int stwtype;

{

  int currentfield;

  unsigned char **predframe;

  int DMV[2][2];

  int stwtop, stwbot;



  stwtop = stwtype%3; /* 0:temporal, 1:(spat+temp)/2, 2:spatial */

  stwbot = stwtype/3;



  if ((macroblock_type & MACROBLOCK_MOTION_FORWARD) 

   || (picture_coding_type==P_TYPE))

  {

    if (picture_structure==FRAME_PICTURE)

    {

      if ((motion_type==MC_FRAME) 

        || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))

      {

        /* frame-based prediction (broken into top and bottom halves

             for spatial scalability prediction purposes) */

        if (stwtop<2)

          form_prediction(forward_reference_frame,0,current_frame,0,

            Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,

            PMV[0][0][0],PMV[0][0][1],stwtop);



        if (stwbot<2)

          form_prediction(forward_reference_frame,1,current_frame,1,

            Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,

            PMV[0][0][0],PMV[0][0][1],stwbot);

      }

      else if (motion_type==MC_FIELD) /* field-based prediction */

      {

        /* top field prediction */

        if (stwtop<2)

          form_prediction(forward_reference_frame,motion_vertical_field_select[0][0],

            current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,

            bx,by>>1,PMV[0][0][0],PMV[0][0][1]>>1,stwtop);



        /* bottom field prediction */

        if (stwbot<2)

          form_prediction(forward_reference_frame,motion_vertical_field_select[1][0],

            current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,

            bx,by>>1,PMV[1][0][0],PMV[1][0][1]>>1,stwbot);

      }

      else if (motion_type==MC_DMV) /* dual prime prediction */

      {

        /* calculate derived motion vectors */

        Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]>>1);



        if (stwtop<2)

        {

          /* predict top field from top field */

          form_prediction(forward_reference_frame,0,current_frame,0,

            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,

            PMV[0][0][0],PMV[0][0][1]>>1,0);



          /* predict and add to top field from bottom field */

          form_prediction(forward_reference_frame,1,current_frame,0,

            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,

            DMV[0][0],DMV[0][1],1);

        }



        if (stwbot<2)

        {

          /* predict bottom field from bottom field */

          form_prediction(forward_reference_frame,1,current_frame,1,

            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,

            PMV[0][0][0],PMV[0][0][1]>>1,0);



          /* predict and add to bottom field from top field */

          form_prediction(forward_reference_frame,0,current_frame,1,

            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,

            DMV[1][0],DMV[1][1],1);

        }

      }

      else

        /* invalid motion_type */

        printf("invalid motion_type\n");

    }

    else /* TOP_FIELD or BOTTOM_FIELD */

    {

      /* field picture */

      currentfield = (picture_structure==BOTTOM_FIELD);



      /* determine which frame to use for prediction */

      if ((picture_coding_type==P_TYPE) && Second_Field

         && (currentfield!=motion_vertical_field_select[0][0]))

        predframe = backward_reference_frame; /* same frame */

      else

        predframe = forward_reference_frame; /* previous frame */



      if ((motion_type==MC_FIELD)

        || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))

      {

        /* field-based prediction */

        if (stwtop<2)

          form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0,

            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,

            PMV[0][0][0],PMV[0][0][1],stwtop);

      }

      else if (motion_type==MC_16X8)

      {

        if (stwtop<2)

        {

          form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0,

            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by,

            PMV[0][0][0],PMV[0][0][1],stwtop);



          /* determine which frame to use for lower half prediction */

          if ((picture_coding_type==P_TYPE) && Second_Field

             && (currentfield!=motion_vertical_field_select[1][0]))

            predframe = backward_reference_frame; /* same frame */

          else

            predframe = forward_reference_frame; /* previous frame */



          form_prediction(predframe,motion_vertical_field_select[1][0],current_frame,0,

            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by+8,

            PMV[1][0][0],PMV[1][0][1],stwtop);

        }

      }

      else if (motion_type==MC_DMV) /* dual prime prediction */

      {

        if (Second_Field)

          predframe = backward_reference_frame; /* same frame */

        else

          predframe = forward_reference_frame; /* previous frame */



        /* calculate derived motion vectors */

        Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]);



        /* predict from field of same parity */

        form_prediction(forward_reference_frame,currentfield,current_frame,0,

          Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,

          PMV[0][0][0],PMV[0][0][1],0);



        /* predict from field of opposite parity */

        form_prediction(predframe,!currentfield,current_frame,0,

          Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,

          DMV[0][0],DMV[0][1],1);

      }

      else

        /* invalid motion_type */

        printf("invalid motion_type\n");

    }

    stwtop = stwbot = 1;

  }



  if (macroblock_type & MACROBLOCK_MOTION_BACKWARD)

  {

    if (picture_structure==FRAME_PICTURE)

    {

      if (motion_type==MC_FRAME)

      {

        /* frame-based prediction */

        if (stwtop<2)

          form_prediction(backward_reference_frame,0,current_frame,0,

            Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,

            PMV[0][1][0],PMV[0][1][1],stwtop);



        if (stwbot<2)

          form_prediction(backward_reference_frame,1,current_frame,1,

            Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,

            PMV[0][1][0],PMV[0][1][1],stwbot);

      }

      else /* field-based prediction */

      {

        /* top field prediction */

        if (stwtop<2)

          form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],

            current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,

            bx,by>>1,PMV[0][1][0],PMV[0][1][1]>>1,stwtop);



        /* bottom field prediction */

        if (stwbot<2)

          form_prediction(backward_reference_frame,motion_vertical_field_select[1][1],

            current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,

            bx,by>>1,PMV[1][1][0],PMV[1][1][1]>>1,stwbot);

      }

    }

    else /* TOP_FIELD or BOTTOM_FIELD */

    {

      /* field picture */

      if (motion_type==MC_FIELD)

      {

        /* field-based prediction */

        form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],

          current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,

          bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);

      }

      else if (motion_type==MC_16X8)

      {

        form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],

          current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,

          bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);



        form_prediction(backward_reference_frame,motion_vertical_field_select[1][1],

          current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,

          bx,by+8,PMV[1][1][0],PMV[1][1][1],stwtop);

      }

      else

        /* invalid motion_type */

        printf("invalid motion_type\n");

    }

  }

}



static void form_prediction(src,sfield,dst,dfield,lx,lx2,w,h,x,y,dx,dy,average_flag)

unsigned char *src[]; /* prediction source buffer */

int sfield;           /* prediction source field number (0 or 1) */

unsigned char *dst[]; /* prediction destination buffer */

int dfield;           /* prediction destination field number (0 or 1)*/

int lx,lx2;           /* line strides */

int w,h;              /* prediction block/sub-block width, height */

int x,y;              /* pixel co-ordinates of top-left sample in current MB */

int dx,dy;            /* horizontal, vertical prediction address */

int average_flag;     /* add prediction error to prediction ? */

{

  /* Y */

  form_component_prediction(src[0]+(sfield?lx2>>1:0),dst[0]+(dfield?lx2>>1:0),

    lx,lx2,w,h,x,y,dx,dy,average_flag);



  if (chroma_format!=CHROMA444)

  {

    lx>>=1; lx2>>=1; w>>=1; x>>=1; dx/=2;

  }



  if (chroma_format==CHROMA420)

  {

    h>>=1; y>>=1; dy/=2;

  }



  /* Cb */

  form_component_prediction(src[1]+(sfield?lx2>>1:0),dst[1]+(dfield?lx2>>1:0),

    lx,lx2,w,h,x,y,dx,dy,average_flag);



  /* Cr */

  form_component_prediction(src[2]+(sfield?lx2>>1:0),dst[2]+(dfield?lx2>>1:0),

    lx,lx2,w,h,x,y,dx,dy,average_flag);

}



/* ISO/IEC 13818-2 section 7.6.4: Forming predictions */

/* NOTE: the arithmetic below produces numerically equivalent results

 *  to 7.6.4, yet is more elegant. It differs in the following ways:

 *

 *   1. the vectors (dx, dy) are based on cartesian frame 

 *      coordiantes along a half-pel grid (always positive numbers)

 *      In contrast, vector[r][s][t] are differential (with positive and 

 *      negative values). As a result, deriving the integer vectors 

 *      (int_vec[t]) from dx, dy is accomplished by a simple right shift.

 *

 *   2. Half pel flags (xh, yh) are equivalent to the LSB (Least

 *      Significant Bit) of the half-pel coordinates (dx,dy).

 * 

 *

 *  NOTE: the work of combining predictions (ISO/IEC 13818-2 section 7.6.7)

 *  is distributed among several other stages.  This is accomplished by 

 *  folding line offsets into the source and destination (src,dst)

 *  addresses (note the call arguments to form_prediction() in Predict()),

 *  line stride variables lx and lx2, the block dimension variables (w,h), 

 *  average_flag, and by the very order in which Predict() is called.  

 *  This implementation design (implicitly different than the spec) 

 *  was chosen for its elegance.

*/



static void form_component_prediction(src,dst,lx,lx2,w,h,x,y,dx,dy,average_flag)

unsigned char *src;

unsigned char *dst;

int lx;          /* raster line increment */ 

int lx2;

int w,h;

int x,y;

int dx,dy;

int average_flag;      /* flag that signals bi-directional or Dual-Prime 

                          averaging (7.6.7.1 and 7.6.7.4). if average_flag==1,

                          a previously formed prediction has been stored in 

                          pel_pred[] */

{

  int xint;      /* horizontal integer sample vector: analogous to int_vec[0] */

  int yint;      /* vertical integer sample vectors: analogous to int_vec[1] */

  int xh;        /* horizontal half sample flag: analogous to half_flag[0]  */

  int yh;        /* vertical half sample flag: analogous to half_flag[1]  */

  int i, j, v;

  unsigned char *s;    /* source pointer: analogous to pel_ref[][]   */

  unsigned char *d;    /* destination pointer:  analogous to pel_pred[][]  */



  /* half pel scaling for integer vectors */

  xint = dx>>1;

  yint = dy>>1;



  /* derive half pel flags */

  xh = dx & 1;

  yh = dy & 1;



  /* compute the linear address of pel_ref[][] and pel_pred[][] 

     based on cartesian/raster cordinates provided */

  s = src + lx*(y+yint) + x + xint;

  d = dst + lx*y + x;



  if (!xh && !yh) /* no horizontal nor vertical half-pel */

  {

    if (average_flag)

    {

      for (j=0; j<h; j++)

      {

        for (i=0; i<w; i++)

        {

          v = d[i]+s[i];

          d[i] = (v+(v>=0?1:0))>>1;

        }

      

        s+= lx2;

        d+= lx2;

      }

    }

    else

    {

      for (j=0; j<h; j++)

      {

        for (i=0; i<w; i++)

        {

          d[i] = s[i];

        }

        

        s+= lx2;

        d+= lx2;

      }

    }

  }

  else if (!xh && yh) /* no horizontal but vertical half-pel */

  {

    if (average_flag)

    {

      for (j=0; j<h; j++)

      {

        for (i=0; i<w; i++)

        {

          v = d[i] + ((unsigned int)(s[i]+s[i+lx]+1)>>1);

          d[i]=(v+(v>=0?1:0))>>1;

        }

     

        s+= lx2;

        d+= lx2;

      }

    }

    else

    {

      for (j=0; j<h; j++)

      {

        for (i=0; i<w; i++)

        {

          d[i] = (unsigned int)(s[i]+s[i+lx]+1)>>1;

        }



        s+= lx2;

        d+= lx2;

      }

    }

  }

  else if (xh && !yh) /* horizontal but no vertical half-pel */

  {

    if (average_flag)

    {

      for (j=0; j<h; j++)

      {

        for (i=0; i<w; i++)

        {

          v = d[i] + ((unsigned int)(s[i]+s[i+1]+1)>>1);

          d[i] = (v+(v>=0?1:0))>>1;

        }

     

        s+= lx2;

        d+= lx2;

      }

    }

    else

    {

      for (j=0; j<h; j++)

      {

        for (i=0; i<w; i++)

        {

          d[i] = (unsigned int)(s[i]+s[i+1]+1)>>1;

        }



        s+= lx2;

        d+= lx2;

      }

    }

  }

  else /* if (xh && yh) horizontal and vertical half-pel */

  {

    if (average_flag)

    {

      for (j=0; j<h; j++)

      {

        for (i=0; i<w; i++)

        {

          v = d[i] + ((unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2);

          d[i] = (v+(v>=0?1:0))>>1;

        }

     

        s+= lx2;

        d+= lx2;

      }

    }

    else

    {

      for (j=0; j<h; j++)

      {

        for (i=0; i<w; i++)

        {

          d[i] = (unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2;

        }



        s+= lx2;

        d+= lx2;

      }

    }

  }

}

